.TH std::is_layout_compatible 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::is_layout_compatible \- std::is_layout_compatible

.SH Synopsis
   Defined in header <type_traits>
   template< class T, class U >     \fI(since C++20)\fP
   struct is_layout_compatible;

   If T and U are layout-compatible types, provides the member constant value equal to
   true. Otherwise value is false.

   Every type is layout-compatible with its any cv-qualified versions, even if it is
   not an object type.

   If T or U is not a complete type, (possibly cv-qualified) void, or an array of
   unknown bound, the behavior is undefined.

   If an instantiation of a template above depends, directly or indirectly, on an
   incomplete type, and that instantiation could yield a different result if that type
   were hypothetically completed, the behavior is undefined.

   If the program adds specializations for std::is_layout_compatible or
   std::is_layout_compatible_v, the behavior is undefined.

.SH Member constants

   value    true if T and U are layout-compatible, false otherwise
   \fB[static]\fP \fI(public static member constant)\fP

.SH Member functions

   operator bool converts the object to bool, returns value
                 \fI(public member function)\fP
   operator()    returns value
   \fI(C++14)\fP       \fI(public member function)\fP

.SH Member types

   Type       Definition
   value_type bool
   type       std::integral_constant<bool, value>

.SH Notes

   A signed integer type and its unsigned counterpart are not layout-compatible. char
   is layout-compatible with neither signed char nor unsigned char.

   Similar types are not layout-compatible if they are not the same type after ignoring
   top-level cv-qualification.

   An enumeration type and its underlying type are not layout-compatible.

   Array types of layout-compatible but different element types (ignoring
   cv-qualification) are not layout-compatible, even if they are of equal length.

         Feature-test macro        Value    Std            Feature
   __cpp_lib_is_layout_compatible 201907L (C++20) std::is_layout_compatible

.SH Example


// Run this code

 #include <iomanip>
 #include <iostream>
 #include <type_traits>

 struct Foo
 {
     int x;
     char y;
 };

 struct FooNua
 {
     int x;
     [[no_unique_address]] char y;
 };

 class Bar
 {
     const int u = 42;
     volatile char v = '*';
 };

 enum E0 : int {};
 enum class E1 : int {};

 static_assert
 (
     std::is_layout_compatible_v<const void, volatile void> == true  and
     std::is_layout_compatible_v<Foo, Bar>                  == true  and
     std::is_layout_compatible_v<Foo[2], Bar[2]>            == false and
     std::is_layout_compatible_v<int, E0>                   == false and
     std::is_layout_compatible_v<E0, E1>                    == true  and
     std::is_layout_compatible_v<long, unsigned long>       == false and
     std::is_layout_compatible_v<char*, const char*>        == false and
     std::is_layout_compatible_v<char*, char* const>        == true  and
     std::is_layout_compatible_v<Foo, FooNua>               == false // Note [1]
 );

 // [1] MSVC erroneously fails this assert

 int main() {}

.SH See also

   is_standard_layout checks if a type is a standard-layout type
   \fI(C++11)\fP            \fI(class template)\fP
